<possibleDataStructures>

	doubleArray = constant size array of java type double
	nodeArray = constant size 
	node = constant size sequence of doubleArray and/or nodeArray
		with network-defined requirements on the combinations of sizes of those arrays.
	network = dynamicly sorted list of nodes,
		and an immutable (and same for each node) definition of size requirements on arrays of each node,
		and an immutable algorithm to execute on each node which may change the order of nodes in this network,
		and maybe algorithms for adding or removing or merging or duplicating nodes as childs of other nodes.
	node* = multiply 2 arrays of node, which can be viewed as pairs of nodes to iterate over.
	node^ = array of node power other array of node, which can be viewed as pairs of nodes to iterate over.
	audivolvFunc = function which uses the same floating point array (of a specific size) as input and output.
	iterator = immutable algorithm in a network which iterates over any parts of 1 node.
		If it is standardized in the network, multiple iterators could run on each node, wrapped in 1 function.
	fpArray+ = concat 2 floating point sequences.
		Example: floating point array size 3
			concat 1 floating point from an array size 2^5 is size 4 in each iteration.
	
	In a network, the same iterator algorithm(s) must be for all nodes. If there are many,
	can complex if/else conditions change the order of iterators or choose if they run?
	
	In a network, should there be multiple dynamicly sorted lists of the same nodes?
	It could run different algorithms on on first node in each of the different lists.
	But that is complex so it would have to give me a valuable feature, which I can not think of now.
	
	Should size of a node list be able to depend on node^ of other node lists?
	Certainly node* for node lists is needed, and node^ is needed for floating point arrays.
	For completeness, since node* is needed, node^ should also be allowed.
	
	fpArray+ should be only for the floating points used in iterators, not any of the arrays in nodes.
	
	Size of all doubleArrays and nodeArrays should be defined by all 3 of these:
		int min,
		int max,
		recursive function including *, ^, and/or size of nodeArray(s) in this node or network.
	Size should not be allowed to depend on +.
	
	Should size of doubleArray be allowed to depend on size of other doubleArray (instead of nodeArray)?
	If not, it could be impractical to have a doubleArray size 3*(2^bayesChilds)		
	
	Network should contain some nodeArrays if their contents do not change between nodes.
	Example: [nodeSortValue]
	Example: [bayesFalse,bayesTrue]
	Example: [bayesChance,bayesChanceCertainty,bayesWantChanceCertainty]
	Similarly, network can also contain immutable doubleArrays.
	Other nodeArrays go in the nodes.
	Example: [...bayes childs...] may have size between 0 and 6
	Other doubleArrays go in the nodes.
	Example: [...bayes weights...] probably has size bayesTF^bayesChilds
	
	Because al algorithms are run from a network and not its nodes,
	it is not necessary for nodes to contain the floating points used for sorting those nodes.
	If its efficient, those floating points could instead be 1 doubleArray
	the same size as its nodeArray.
	
	Should all arrays have size which depends on at most 2 other arrays?
	For example, instead of:
		d = x*(y^z)
	Use these multiple sizes:
		c = y^z
		d = x*c
	Arrays can be shared in the network or individual to each node,
		so multiplying by a constant is made efficient by having that constant in the network.
	Similarly, int min and max can be represented without any literal ints by using arrays that size.
	For example, if a node can have at most 30000 childs,
		it is practical to keep 1 nodeArray size 30000 in the network which contains the same node 30000 times.
		If that was impractical, then 1 node having that many childs is also impractical.
	No int constants are allowed. Literal arrays are allowed.
	
	The size of an array is exactly specified by the sequence of 4 arrays.
	Some of those 4 arrays can be in the node therefore must tell where the array is but have no pointer.
	arraySizeRequirement[0] = nodeArray whose size equals my min size.
	arraySizeRequirement[1] = nodeArray whose size equals my max size.
	arraySizeRequirement[2] = nodeArray whose size is the first parameter of * or ^.
	arraySizeRequirement[3] = nodeArray whose size is the second parameter of * or ^.
	But that does not tell which of * or ^.
	
	How would that handle using 2*12^3 with 2^12?
	2^12 easily pairs with 2*12, but that selects only 1 of the 12 at a time.
	What if I wanted to select 2 3 or 7 of the 12 at a time?
	Is fibonacci related here? Can fibonacci be another operator like * and ^?
	Do the simple array size definitions above (allowing only 1 operator with 2 parameters) allow that?
	
	
	How to specify which nodeArrays (in a node X) must contain X (always at index 0?)?
	For example, it would simplify the design of bayesian nodes if their childs include themself first.
	
	
	The next text is copied from other file and I will modify it...
	
	How should floats.size="node*(chanceAccuracyWant node^(bayesTruthConstants childNodes))"
	be combined with shorterFloatList.size="bayesTruthConstants * childNodes"?
	Confusing...
	"node*( childNodes node*(chanceAccuracyWant node^(bayesTruthConstants childNodes)) )"
	
	Lets simplify it and solve that problem later. Solve this first...
	"node*( childNodes node^(bayesTruthConstants childNodes) )"
	double d[] = new double[?];
	pow = (int) bayesTruthConstants power childNodes;
	for(nodeX in childNodes){
		for(p from 0 to pow-1){
			...todo write the pseudocode here...
		}
	}
	
	Lets try something easier. The problem is node lists can be used any number of times,
	and current thinking makes them all be used exactly once.
	It should be this form: codeTreeFrom --> codeTreeTo, where each part of codeTreeFrom points to some part of codeTreeTo, and all parts of codeTreeTo are pointed to at least once, but some parts of codeTreeFrom may not point to anything.
	
	Can it handle this one?:
	"node^(bayesTruthConstants1 childNodes1)" --> "node*(bayesTruthConstants0 childNodes0)"
	Maybe write it this way?:
	"node*( node*(bayesTruthConstants0 childNodes0) node^(bayesTruthConstants1 childNodes1) )"
	--> "node*(bayesTruthConstants0 childNodes0)"

	Example:
	"node*( node*(bayesTruthConstants0 childNodes0) node^(bayesTruthConstants1 childNodes1) )"
	--> "node*(bayesTruthConstants0 childNodes0)"
	But that does not specify that bayesTruthConstants does not increase the iteration size.
	For example, 2*5 * 2^5 has 5 * 2^5 iterations and 2*5 output size
	That could be written without the arrow -->, like this:
	"node*( node*(bayesTruthConstants_inonly childNodes_inandout) node^(bayesTruthConstants_inonly childNodes_inonly) )"
	
	Example: "node*(x node^(y x))" --> "node*(x y)"
	
	Theory: outputs sets and sizes <= inputs sets and sizes <= iterationSize
	
	Find counterexample where output sets contain anything that input sets do not.{
		If found, change:
		Theory: outputs sets and sizes <= inputs sets and sizes <= iterationSize
		
		Example: "neuralWeights" --> "1" //sums neural weights
		Fix example: "1 + neuralWeights" --> "1"
		
		If part of an output is not in the input, can it be trivially added?

	}

	Find example where input sets are smaller than iterationSize.{
		If that exists, use this theory instead:
		Theory: outputs sets and sizes <= inputs sets and sizes <= iterationSize

		If iterationSize is X times bigger than [inputs sets and sizes], multiply inputs by X.
	}

</possibleDataStructures>